\newpage
\chapter{Outil d'Explorer3d et Performances}
\section{Loupe}
\paragraph{}
Un outil spécifique à Explorer3d et très apprécié par ses concepteurs est la présence d'une loupe permettant d'avoir un aperçu précis d'une région de la scène 3d. Cette loupe permet nottament de sélectionner et visualiser plus précisément des éléments tout en continuant à naviguer dans la scène. 
\\ \\

\begin{center}
\includegraphics[scale=0.5]{loupe_exp.png}\\
\textit{Aperçu de la loupe d'Explorer3d}
\end{center}
\vspace{1cm}

\paragraph{}
Nous avons étudié les outils proposés par RGL et RGtk2 afin de pouvoir reproduire cette loupe ou du moins une alternative. Il apparait que la méthode utilisée au sein d'Explorer3d, à savoir réaliser une copie en deux dimensions de la scène 3d et effectuer des altérations sur cette image, peut en partie être imitée sous R. En effet, RGL possède une fonction rgl.snapshot("loupe.png") qui permet d'enregistrer une capture d'écran de la fenêtre sous le nom de fichier passé en paramètre. Néanmoins RGL ne permet pas d'utiliser les images en deux dimensions comme nous souhaitons le faire. 

\paragraph{}
Nous nous sommes tournés vers RGtk2 qui offre quelques fonctionnalités de gestion d'images. Au final nous pouvons faire apparaitre l'image prise par RGL dans une fenêtre RGtk2, mais les possibilités sont là-aussi limitées. Il existe des outils sous R qui permettent de manipuler efficacement les images mais celles-ci nécessitent d'utiliser d'autres librairies que nous n'avons pas eu le temps d'étudier en détail.

\paragraph{}
Nous avons toutefois effectué quelques recherches pour déterminer quelles librairies seraient susceptibles de convenir à un développement approfondit. EBImage semble au final être un package offrant des fonctionnalités qui pourraient convenir.

\paragraph{}
Pour pouvoir porter la loupe sous R, plusieurs fonctionnalités sont nécessaires. Certaines d'entre elles existent, mais elles impliquent d'effectuer des modifications dans le code source même de RGL et probablement aussi de RGtk2. 
\vspace{5mm}


\begin{center}
\includegraphics[scale=0.5]{loupe_r.png}\\
\textit{Aperçu de l'ébauche d'une loupe portée sous R}
\end{center}
\vspace{1cm}

\begin{lstlisting}
rgl.snapshot("loupe.png")
fenetre2 = gtkWindow()
img = gtkImageNewFromFile("loupe.png")
fenetre2$title="Test loupe"
superpanel2 = gtkVBoxNew(FALSE,8)
frame2=gtkFrameNew()
fenetre2$add(frame2)
frame2$add(superpanel2)
superpanel2$packStart(img,FALSE,FALSE,0)
\end{lstlisting}

\paragraph{}
Voici l'extrait de code permettant d'afficher la capture d'écran RGL dans une fenêtre RGtk2. Nous sommes à présent limités par RGL et RGtk2. Pour avancer plus loin dans le développement de la loupe il faudrait effectuer des modifications dans les codes sources R de RGL et RGtk2. 

\paragraph{}
Nous avons localisé les fonctions concernées afin que les développeurs futurs qui seront amenés à travailler sur ce portage n'aient pas à effectuer cette recherche. Toutefois réaliser cette application risque d'être complexe.

\paragraph{}
Voici les fonctions utiles en question qu'il faudrait réutiliser et/ou modifier afin de pouvoir porter la loupe sur R :

\begin{lstlisting}
# RGTK :
#renvoie les coordonnees de la souris par rapport
# a la fenetre rgtk (coin haut gauche)
pos <- gdkWindowGetPointer(fenetre2)		
# pos$x et pos$y sont accessibles
	
# renvoie la position de la fenetre RGtk2
# par rapport au bureau de l'utilisateur
# (coin haut gauche)
gtkWindowSetGravity(fenetre2,"north-west")
pos<-gtkWindowGetPosition(fenetre2)
#stocke les coordonnees dans pos$root.x et pos$root.y

# RGL :
# renvoie les coordonnees de la souris par rapport
# a la fenetre RGL
select3d->rgl.select3d->rgl.select->rgl.selectstate->rgl_setselectstate.c 

# stocke la position des angles de la fenetre rgl
# par rapport au bureau de l'utilisateur
open3d()
pos<-par3d("windowRect")

\end{lstlisting}

\newpage
\section{Performances de RGL}
\paragraph{}
Au sein d'Explorer3d il est courant d'afficher sur la scène Java3d un nombre très important d'objets. Ainsi nous savons qu'Explorer3d est capable d'afficher facilement plus de 60 000 sphères tout en conservant des performances acceptables.

\paragraph{}
Nous savions avant d'entamer ces recherches en portabilité sous R que nous aurions difficilement les mêmes performances. Avant d'avoir des estimations précises des capacités de RGL nous avons effectué une batterie de tests. Nous avons simplement augmenté le nombre de sphères à afficher dans la fenêtre jusqu'à atteindre les limites de RGL.\\ \\

\begin{tabular}{|l|c|r|}
  \hline
  1000 sphères & performances acceptables \\
  \hline
  5000 sphères & temps de chargement longs et navigation fluide\\
  \hline
  10 000 sphères & temps de chargement longs et navigation saccadée\\
  \hline
  20 000 sphères & temps de chargement de plus de 15s et navigation difficile\\
  \hline
  60 000 sphères & temps de chargement supérieurs à 45s\\
  \hline
\end{tabular}

\paragraph{}
Une lecture rapide des résultats permet de se rendre compte que R est effectivement beaucoup moins performant que java (au moins quatre fois moins performant).

\paragraph{}
Il faut cependant garder en mémoire que nous n'avons pas effectué de recherches destinées à optimiser les performances de RGL, par exemple en diminuant le nombre de facettes affichées ou en diminuant le nombre d'images par secondes.